package estadistec.grafico;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableColumn;
import javax.swing.BorderFactory;
import javax.swing.DefaultCellEditor;
import javax.swing.JInternalFrame;
import javax.swing.JLayeredPane;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.JTable;

import java.awt.*;
import java.awt.event.*;

import javax.swing.border.*;


import estadistec.logica.tabla.*;
import estadistec.logica.*;

/**
 * Clase encargada de la solicitud de los datos para crear un nuevo atributo
 * solicita los datos(nombre,tipo,formula), evalua los datos y se encarga tanto de la creacion
 * atributo  grafico como la  invocacion para crear el atributo a nivel logico
 */

public class VentanaModificarAtributo extends  JInternalFrame implements   ConstantesGraficas,ActionListener,MouseListener, MouseMotionListener
{
	/*
	 * declaracion de componentes graficos
	 */
	
	
     protected  JPopupMenu menuCasos;
    
    /* items, que serán  agregados al menu casos*/
    
    /** opción para modificar las propiedades de un atributo */
    protected  JMenuItem modificarPropiedades; 
    
    /**opción para eliminar un atributo*/
    protected  JMenuItem eliminarAtributo;
    
	/**
	 * panel en el cual se agregaran todos los componentes gráficos */
	protected  JPanel principal;
	
	/**
	 * campo de texto para obtener el nombre del atributo*/
	private JTextField nombre; 
	
	/**
	 * campo de texto para formula atributo*/
	private JTextField formula; 
	
	/**
	 * check para activar formula  si se desea o no poner una fórmula al atributo*/
	private JCheckBox ActivarFormula;
	
	/**
	 * etiqueta para el campo de texto del nombre */
	private JLabel etiquetaNombre; 
	
	/**
	 * etiqueta para el tipo de atributo( cuantitativo - cualitativo )*/
	private JLabel etiquetaTipo;
	
	/**
	 * etiqueta  para el número de decimales a mostrar en un atributo */
	private JLabel etiquetaNumeroDecimales;
	
	/**
	 * etiqueta para el espacio muestral*/
	private JLabel etiquetaEspacioMuestral;
	
	/**
	 * tipo de atributo cualitativo*/
	private JRadioButton tipoCualitativo; 
	
	/**
	 * tipo de atributo cuantitativo*/
	private JRadioButton tipoCuantitativo;
	
	/**
	 * etiqueta que se activará si el nombre esta repetido */
	private JLabel  indicadorNombreRepetido;
	
	/**
	 * etiqueta que se activará si el nombre  cumple con las condiciones de formato y no esta repetido */
	private JLabel  indicadorNombreBien; 

	/**
	 * etiqueta que se activará si el nombre  incumple con el formato establecido */
	private JLabel  indicadorNombreIncorrecto; 
	
	/**
	 * botón  para solicitar que se abra la opción de ayuda */
	private JButton  indicadorAyuda;

	/**
	 * botón cancelar  la creación de un nuevo atributo*/
	private JButton  cancelar;
	
	/**
	 * botón  para solicitar que se abra la opción de ayuda*/
	private JButton  aceptar;
	
	/**
	 *  botón para verificar que la formula cumpla con el formato correcto */
	private JButton  verificar; 
	
	/**
	 * combo para seleccionar el numero de decimales a usar*/
	private JComboBox  listaDecimales;  
	
	/**
	 * combo para ingresar la lista de  datos del espacio muestral */
	private JComboBox  espacioMuestral; 
	
	/**
	 * panel con los componentes para solictar y verificar la fórmula
	 */
	private JPanel  panelFormula;
	
	//private javax.swing.DefaultComboBoxModel ModeloLista = new javax.swing.DefaultComboBoxModel(new String[]{});
	
	/**
	 * tipo cuantivativo entero */	
	private JRadioButton subTipoEntero;
	
	/**
	 * tipo cuantivativo  flotante con  decimales  a mostrar de 0 - 6 */
	private JRadioButton subTipoFlotante;
	
	/**
	 * tipo cuantivativo  intervalo para cada una de las celdas  */
	private JRadioButton subTipoIntervalo;
	
	/**
	 * tipo cuantivativo booleano */
	private JRadioButton subTipoBooleano;	

	
	 /**JTable para copia de la tabla original*/
	 private JTable tablita;
	 
	
	 /**modelo de la tabla*/
	 private DefaultTableModel  modeloTablaCasos;
	 
	 
	 /**número de casos de la tabla*/
	 
	 private int _columnas;
	 
	 
     /**número de casos de la tabla*/
	 
	 private int _valor;
	 
	 
	 
	/**
	 * indicador de si se desea ingresar formula*/
	 private boolean indicadorFormula;
	 
	 
	 /**
	 * indicador de si el estado del atributo es aceptable */
	 private boolean estadoFinal;
	 
	 	
    /**
     * escritorio actual */
	 static GEscritorio escritorioActual;
	 
	 
	 /**
	  * nombre del atributo el cual es valido  solo si cumple con el formato establecido para nombres */
	 private String _nombre;
	 
	 /**
	  *fórmula para calcular el valor del atributo, es validada para ver si su formato es correcto.
	  */
	 private String _formula;
	 
	 /**
	  *entero  que nos  indica si el  atrbutos es cuantitativo o cualitativo.
	  */
	 private int _tipo;
	 
	 /**
	  * cantidad de decimales a mostrar en caso de sea cuantitativo flotante.
	  */
	 private int _numeroDecimales;
	 
	 /** listado de los objetos del  espacio muestral en caso de atributos cualitativos o listado de intervalos para cada atributo */
	 private String[] _arregloTipos; 
	 
	 /** estado final del atributo(será true solo si sus datos son correctos)*/
	 private boolean _estadoFinal;
	 
	
	 /**instancia de la clase tabla para establecer la relación (tabla- ventana atributos) */
	 private GTabla tablaReal;
	
	
	public VentanaModificarAtributo(String nombreAtributo)
	{  
		
		super("Modificar Propiedades del Atributo");
		
		    menuCasos = new JPopupMenu();
	  	    
	  	    /* inicilizar  items del menu casos y poner sus etiquetas  */
	  	 	modificarPropiedades = new JMenuItem("Modificar Item");
	        eliminarAtributo = new JMenuItem("Eliminar Item");
	        
	        
	        modificarPropiedades.addActionListener(this);
			eliminarAtributo.addActionListener(this);
	  	 	/* agregar los componentes al menu caso */
	        menuCasos.add(modificarPropiedades);
	        menuCasos.add(eliminarAtributo);
	        
	    	/*
	    	 * agregar a la tabla casos el menucasos
	    	 */
	  	 	
	  	 	
		    indicadorFormula = true;
		     
		    estadoFinal = false;
		
		
		/*
		 * cargar las dimenciones, color y posicion  de lso componentes gr�ficos
		 */
		
		
		tablita= new JTable();
		
		modeloTablaCasos = new  DefaultTableModel ();
		
		principal = new JPanel();
		principal.setBorder(BorderFactory.createTitledBorder(" "));
		principal.setLocation(CONFIG.cargarPunto("ORIGEN"));
		principal.setSize(CONFIG.cargarDimension("VENTANA_ATRIBUTOS"));
		principal.setVisible(true);
		principal.setBackground(ESTILO.getPrimary3());
		
		etiquetaNombre = new JLabel();
		etiquetaNombre.setLocation(CONFIG.cargarPunto("ETIQUETA_NOMBRE"));
		etiquetaNombre.setSize(CONFIG.cargarDimension("ETIQUETA"));
		etiquetaNombre.setText("Nombre");
		etiquetaNombre.setVisible(true);
		
		nombre = new JTextField();
		nombre.setLocation(CONFIG.cargarPunto("NOMBRE_ATRIBUTO"));
		nombre.setSize(CONFIG.cargarDimension("NOMBRE_ATRIBUTO"));
		nombre.setText(nombreAtributo);
		nombre.setVisible(true);
		nombre.setBackground(ESTILO.getWhite());
		nombre.addActionListener(this);
		
		
		etiquetaTipo = new JLabel();
		etiquetaTipo.setLocation(CONFIG.cargarPunto("ETIQUETA_TIPO"));
		etiquetaTipo.setSize(CONFIG.cargarDimension("ETIQUETA"));
		etiquetaTipo.setText("Tipo");
		etiquetaTipo.setVisible(true);
		
		tipoCualitativo = new JRadioButton();
		tipoCualitativo.setLocation(CONFIG.cargarPunto("TIPO_CUALITATIVO"));
		tipoCualitativo.setSize(CONFIG.cargarDimension("TIPO_CUALITATIVO"));
		tipoCualitativo.setText("Cualitativo");
		tipoCualitativo.setVisible(true);
		tipoCualitativo.setBorder(null);
		tipoCualitativo.setBackground(ESTILO.getWhite());
		tipoCualitativo.addActionListener(this);
		tipoCualitativo.setEnabled(false);
		
		
		tipoCuantitativo = new JRadioButton();
		tipoCuantitativo.setLocation(CONFIG.cargarPunto("TIPO_CUANTITATIVO"));
		tipoCuantitativo.setSize(CONFIG.cargarDimension("TIPO_CUALITATIVO"));
		tipoCuantitativo.setText("Cuantitativo");
		tipoCuantitativo.setVisible(true);
		tipoCuantitativo.setBorder(null);
		tipoCuantitativo.setBackground(ESTILO.getWhite());
		tipoCuantitativo.addActionListener(this);
		tipoCuantitativo.setSelected(true);
		tipoCuantitativo.setEnabled(false);
		
		indicadorNombreBien =  new JLabel(new ImageIcon(IMAGENESBOTONES[0]));
		indicadorNombreBien.setLocation(CONFIG.cargarPunto("INDICADOR_NOMBRE1"));
		indicadorNombreBien.setSize(CONFIG.cargarDimension("BOTON_HERRAMIENTA"));
		indicadorNombreBien.setVisible(true);
		indicadorNombreBien.setBorder(null);
		indicadorNombreBien.setBackground(ESTILO.getWhite());
		
		indicadorNombreRepetido =  new JLabel(new ImageIcon(IMAGENESBOTONES[1]));
		indicadorNombreRepetido.setLocation(CONFIG.cargarPunto("INDICADOR_NOMBRE2"));
		indicadorNombreRepetido.setSize(CONFIG.cargarDimension("BOTON_HERRAMIENTA"));
		indicadorNombreRepetido.setVisible(true);
		indicadorNombreRepetido.setBorder(null);
		indicadorNombreRepetido.setBackground(ESTILO.getWhite());

		indicadorNombreIncorrecto =  new JLabel(new ImageIcon(IMAGENESBOTONES[2]));
		indicadorNombreIncorrecto.setLocation(CONFIG.cargarPunto("INDICADOR_NOMBRE3"));
		indicadorNombreIncorrecto.setSize(CONFIG.cargarDimension("BOTON_HERRAMIENTA"));
		indicadorNombreIncorrecto.setVisible(true);
		indicadorNombreIncorrecto.setBorder(null);
		indicadorNombreIncorrecto.setBackground(ESTILO.getWhite());
		
		indicadorAyuda =  new JButton(new ImageIcon(IMAGENESBOTONES[3]));
		indicadorAyuda.setLocation(CONFIG.cargarPunto("INDICADOR_AYUDA"));
		indicadorAyuda.setSize(CONFIG.cargarDimension("BOTON_HERRAMIENTA"));
		indicadorAyuda.setVisible(true);
		indicadorAyuda.setBorder(null);
		indicadorAyuda.setBackground(ESTILO.getWhite());
		indicadorAyuda.addActionListener(this);
					
		etiquetaNumeroDecimales= new JLabel();
		etiquetaNumeroDecimales.setLocation(CONFIG.cargarPunto("ET_NUMDECIMALES"));
		etiquetaNumeroDecimales.setSize(CONFIG.cargarDimension("ETIQUETA_L"));
		etiquetaNumeroDecimales.setText("N�m decimales");
		etiquetaNumeroDecimales.setVisible(true);
		
		etiquetaEspacioMuestral= new JLabel();
		etiquetaEspacioMuestral.setLocation(CONFIG.cargarPunto("ET_NUMDECIMALES"));
		etiquetaEspacioMuestral.setSize(CONFIG.cargarDimension("ETIQUETA_L"));
		etiquetaEspacioMuestral.setText("Espacio Muestral");
		etiquetaEspacioMuestral.setVisible(false);
	
		
		listaDecimales =  new JComboBox();
		listaDecimales.setLocation(CONFIG.cargarPunto("LISTA_DECIMALES"));
		listaDecimales.setSize(CONFIG.cargarDimension("LISTA_DECIMALES"));
		listaDecimales.setModel(new javax.swing.DefaultComboBoxModel(new String[]{"1","2","3","4","5","6"}));
		listaDecimales.setBackground(ESTILO.getWhite());
		listaDecimales.setVisible(true);
		listaDecimales.setEditable(false);
		listaDecimales.addActionListener(this);
		
		
		
		espacioMuestral =  new JComboBox();
		espacioMuestral.setLocation(CONFIG.cargarPunto("LISTA_DECIMALES"));
		espacioMuestral.setSize(CONFIG.cargarDimension("ESPACIO_MUESTRAL"));
		espacioMuestral.setModel(new javax.swing.DefaultComboBoxModel(new String[]{}));
		espacioMuestral.setBackground(ESTILO.getWhite());
		espacioMuestral.setVisible(false);
		espacioMuestral.setEditable(true);  
		
		
	 	
		espacioMuestral.setComponentPopupMenu(menuCasos);
  	
	
		ActivarFormula= new JCheckBox();
		ActivarFormula.setLocation(CONFIG.cargarPunto("FORMULA"));
		ActivarFormula.setSize(CONFIG.cargarDimension("FORMULA"));
		ActivarFormula.setText("Fórmula");
		ActivarFormula.setVisible(true);
		ActivarFormula.setBorder(null);
		ActivarFormula.setBackground(ESTILO.getWhite());
		ActivarFormula.addActionListener(this);
		
		subTipoFlotante = new JRadioButton();
		subTipoFlotante.setLocation(140,80);
		subTipoFlotante.setSize(CONFIG.cargarDimension("SUBTIPO"));
		subTipoFlotante.setText("Flotante");
		subTipoFlotante.setVisible(true);
		subTipoFlotante.setBorder(null);
		subTipoFlotante.setBackground(ESTILO.getWhite());
		subTipoFlotante.addActionListener(this);
		subTipoFlotante.setSelected(true);
		
		subTipoEntero = new JRadioButton();
		subTipoEntero.setLocation(70,80);
		subTipoEntero.setSize(CONFIG.cargarDimension("SUBTIPO"));
		subTipoEntero.setText("Entero");
		subTipoEntero.setVisible(true);
		subTipoEntero.setBorder(null);
		subTipoEntero.setBackground(ESTILO.getWhite());
		subTipoEntero.addActionListener(this);
		subTipoEntero.setSelected(false);
		
	    subTipoBooleano = new JRadioButton();
		subTipoBooleano.setLocation(210,80);
		subTipoBooleano.setSize(CONFIG.cargarDimension("SUBTIPO"));
		subTipoBooleano.setText("Booleano");
		subTipoBooleano.setVisible(true);
		subTipoBooleano.setBorder(null);
		subTipoBooleano.setBackground(ESTILO.getWhite());
		subTipoBooleano.addActionListener(this);
		subTipoBooleano.setSelected(false);
		
		
		subTipoIntervalo = new JRadioButton();
		subTipoIntervalo.setLocation(290,80);
		subTipoIntervalo.setSize(CONFIG.cargarDimension("SUBTIPO"));
		subTipoIntervalo.setText("Intervalo");
		subTipoIntervalo.setVisible(true);
		subTipoIntervalo.setBorder(null);
		subTipoIntervalo.setBackground(ESTILO.getWhite());
		subTipoIntervalo.addActionListener(this);
		subTipoIntervalo.setSelected(false);
		
		
		/* evento para agregar  elementos en el espacio muestral*/
		espacioMuestral.addActionListener(new ActionListener() 
		{ 
			
		  /*
		   * registrar los valores ingresados en el espacio muestral
		   */
			public void actionPerformed(ActionEvent ae) {
			 
			  /*
			   * comprobar si se ha agregado un elemento a combo y que no sea  nulo**/
				
			  if(ae.getActionCommand()== "comboBoxEdited")
	    	  {
	    		  System.out.println(ae.getActionCommand());
	    		  
	    		  if(espacioMuestral.getSelectedItem().toString().length()!= 0)
	    		  {
	    			  espacioMuestral.addItem(espacioMuestral.getSelectedItem()); 
	    		  }  
	    	   }
			}
		});
			
		
		
		cancelar =  new JButton("Cancelar");
		cancelar.setLocation(CONFIG.cargarPunto("CANCELAR_ATRIBUTO"));
		cancelar.setSize(CONFIG.cargarDimension("ACEPTAR_ATRIBUTO"));
		cancelar.setVisible(true);
		cancelar.setBackground(ESTILO.getWhite());
		cancelar.addActionListener(this);
		
		aceptar =  new JButton("Aceptar");
		aceptar.setLocation(CONFIG.cargarPunto("ACEPTAR_ATRIBUTO"));
		aceptar.setSize(CONFIG.cargarDimension("ACEPTAR_ATRIBUTO"));
		aceptar.setVisible(true);
		aceptar.setBackground(ESTILO.getWhite());
		aceptar.addActionListener(this);
		aceptar.setEnabled(true);
		
		
		panelFormula = new JPanel();
		panelFormula.setBorder(BorderFactory.createTitledBorder("formula"));
		panelFormula.setLocation(5,125);
		panelFormula.setSize(380,70);
		panelFormula.setBackground(ESTILO.getWhite());
		panelFormula.setVisible(false);
		
		formula= new JTextField();
		formula.setLocation(CONFIG.cargarPunto("FORMULA_ATRIBUTO"));
		formula.setSize(CONFIG.cargarDimension("ETIQUETA_L"));
		formula.setText("");
		formula.setVisible(true);
		formula.setBackground(ESTILO.getWhite());
		formula.addActionListener(this);
		
		verificar =  new JButton("Verificar");
		verificar.setLocation(CONFIG.cargarPunto("VERIFICAR_FORMULA"));
		verificar.setSize(CONFIG.cargarDimension("ACEPTAR_ATRIBUTO"));
		verificar.setVisible(true);
		verificar.setBackground(ESTILO.getWhite());
		verificar.addActionListener(this);
		
		formula.addMouseMotionListener(this);
		formula.addMouseListener(this);
	
		nombre.addMouseMotionListener(this);
		nombre.addMouseListener(this);
		
		
		panelFormula.add(verificar);
		panelFormula.add(formula);
		panelFormula.add(verificar);
		
		principal.setLayout(null);
		panelFormula.setLayout(null);
		
		principal.add(etiquetaNombre);
		principal.add(etiquetaTipo);
		principal.add(ActivarFormula);
		principal.add(etiquetaEspacioMuestral);
		principal.add(etiquetaNumeroDecimales);
		principal.add(espacioMuestral);
		panelFormula.add(formula);
		principal.add(tipoCualitativo);
		principal.add(tipoCuantitativo);
		principal.add(indicadorNombreRepetido);
		principal.add(indicadorNombreBien);
		principal.add(indicadorNombreIncorrecto);
		principal.add(indicadorAyuda);
		principal.add(aceptar);
		principal.add(cancelar);
		principal.add(nombre);
		principal.add(panelFormula);
		principal.add(listaDecimales);
		//principal.add(subTipoIntervalo);
		principal.add(subTipoEntero);
		principal.add(subTipoBooleano);
		principal.add(subTipoFlotante);	
	
		principal.setBackground(ESTILO.getWhite());
		this.add(principal);
		
	}
	
	/*
	 * Manejador de eventos de la ventana 
	 */
	
	public void actionPerformed(ActionEvent e)
    {
		/**
		 * @todo solicitar la ayuda para crear nuevos atributos
		 * se de crear  una ventana que muestre como crear los atributos,
		 * así como los formatos  tanto para el nombre como la fórmula
		 */
		if(e.getSource()== indicadorAyuda)
		{
			
		}
		
		/*
		 * mostrar  una lista para construir el espacio muestral
		 */
		else if(e.getSource()== tipoCualitativo) 
		{
			/*definir el tipo del atributo */
			
			_tipo = 0;
			
			/* mostrar los componentes nesesarios */
			etiquetaNumeroDecimales.setVisible(false);
			listaDecimales.setVisible(false);
			
			espacioMuestral.setVisible(true);
			etiquetaEspacioMuestral.setVisible(true);
			
			tipoCualitativo.setSelected(true);
			tipoCuantitativo.setSelected(false);
			
			subTipoEntero.setVisible(false);
			subTipoFlotante.setVisible(false);
			subTipoIntervalo.setVisible(false);
			subTipoBooleano.setVisible(false);
			
			aceptar.setEnabled(false);
		}
		
		
		/*
		 * mostrar una lista con la cantidad de decimales a mostrar
		 */
		else if(e.getSource()== tipoCuantitativo )
		{
			/*definir el tipo del atributo**/
			_tipo = 1;
			
			/*mostrar los componentes que sea nesesario*/
			etiquetaNumeroDecimales.setVisible(true);
			listaDecimales.setVisible(true);
			
			espacioMuestral.setVisible(false);
			etiquetaEspacioMuestral.setVisible(false);
			
			tipoCualitativo.setSelected(false);
			tipoCuantitativo.setSelected(true);
			
			
			subTipoEntero.setVisible(true);
			subTipoFlotante.setVisible(true);
			subTipoIntervalo.setVisible(true);
			subTipoBooleano.setVisible(true);
			
			aceptar.setEnabled(true);

		}
		
		
		/*
		 * aceptar la creacion de un nuevo atributo
		 * se evalua si cumple con las condiciones
		 */
		else if(e.getSource()== aceptar)
		{
			
			 if(evaluarAtributo())
			 {
				 //tablita.setValueAt(_nombre,0,_columnas-2); 
				 terminar();
			 }
			 else
			 {   
					JOptionPane.showMessageDialog(null,"Datos incorrectos","Error",JOptionPane.WARNING_MESSAGE);
					aceptar.setEnabled(false);
		     }
		}
		
		/*
		 * cancelar la deficicion de un nuevo atributo
		 * se consulta si se desea eliminar (respuesta = 0)
		 */
		
		else if(e.getSource()== cancelar)
		{	     
				terminar();
		}
		
		/*
		 * activar la solicitud de datos de la formula
		 */
		else if(e.getSource()== ActivarFormula)
		{
			/** si el check de activar es falso*/
			 
			if(indicadorFormula == true)
			{
			    aceptar.setEnabled(false);
				panelFormula.setVisible(true);
				indicadorFormula = false;
				
			}
			else if(indicadorFormula == false)
			{
				aceptar.setEnabled(true);
				panelFormula.setVisible(false);
				indicadorFormula = true;
			}
		}
		
		/*
		 *
		 *  evento para llamar al metodo el cual verificar�  si la formula es correcta
		 */
		else if(e.getSource()== verificar)
		{ 
			/*verificar si la formula es correcta y  habilitar el boton aceptar*/
			if(validarFormula(formula.getText()))
			{
				_formula = formula.getText();
				aceptar.setEnabled(true);
			}
	         
			else
			{   
				JOptionPane.showMessageDialog(null,"Formula incorrecta","Error",JOptionPane.WARNING_MESSAGE);
				aceptar.setEnabled(false);
			}
		}
		
		/*evento para declarar subtipo cuantitativo entero*/
		else if(e.getSource() == subTipoEntero)
		{
			etiquetaNumeroDecimales.setVisible(false);
			listaDecimales.setVisible(false);
			subTipoEntero.setSelected(true);
			subTipoFlotante.setSelected(false);
			subTipoBooleano.setSelected(false);
			subTipoIntervalo.setSelected(false);
		}
		
		/*evento para declarar subtipo cuantitativo flotante */
		else if(e.getSource() == subTipoFlotante)
		{
			etiquetaNumeroDecimales.setVisible(true);
			listaDecimales.setVisible(true);
			subTipoEntero.setSelected(false);
			subTipoFlotante.setSelected(true);
			subTipoBooleano.setSelected(false);
			subTipoIntervalo.setSelected(false);
		}
		/*evento para declarar subtipo cuantitativo  mediante intervalos*/
		else if(e.getSource() == subTipoIntervalo)
		{
			etiquetaNumeroDecimales.setVisible(false);
			listaDecimales.setVisible(false);
			subTipoEntero.setSelected(false);
			subTipoFlotante.setSelected(false);
			subTipoBooleano.setSelected(false);
			subTipoIntervalo.setSelected(true);
		}
		
		/*evento para declarar subtipo cuantitativo booleano*/
		else if(e.getSource() == subTipoBooleano)
		{
			etiquetaNumeroDecimales.setVisible(false);
			listaDecimales.setVisible(false);
			subTipoEntero.setSelected(false);
			subTipoFlotante.setSelected(false);
			subTipoBooleano.setSelected(true);
			subTipoIntervalo.setSelected(false);
		}
		else if(e.getSource() ==  eliminarAtributo)
		{
		     //espacioMuestral.getSelectedItem().toString();
		     //System.out.println("entra");
		     espacioMuestral.removeItem(espacioMuestral.getSelectedItem());
		}
    }
	
	
	/*
     * manejador de eventos del mouse
     */
    public void mouseDragged(MouseEvent e){}
    public void mouseMoved   (MouseEvent e){} 
    public void mouseReleased(MouseEvent e){}
    
    public void mousePressed (MouseEvent e){}
    public void mouseEntered (MouseEvent e){}
    public void mouseClicked (MouseEvent e){}
    
    
    /*
     * posicionarse sobre un componente
     */
    public void mouseExited(MouseEvent e) 
    {
    	/*
    	 *  si se posiciona y escribe sobre el campo del nombre del atributo
    	 */
    	if(e.getSource()== nombre)
    	{
    		validarNombre(nombre.getText());
    	}   	
    }
	/**
	 * M�todo para hacer invisible la ventana
	 */
	public void terminar()
	{
		 this.setVisible(false);
	}
	
	/**
	 * M�todo para hacer visible la ventana
	 */
	public void iniciar()
	{
	   this.setVisible(true);  
	}
	
	/**
	 * Metodo para agregar al escritorio padre ventana de atributos
	 * @param padre
	 */
	public void agregarEscritorio(GEscritorio padre,DefaultTableModel modelo,JTable tabla,GTabla tablaR,int columns,int posicion)
    {
       escritorioActual = padre;
       tablita = tabla;
       tablaReal = tablaR;
       modeloTablaCasos = modelo;
       _columnas = columns;
       _valor = posicion;
    }
 
	 /***
	  * Metodo para retornar el nombre del atributo
	  * @return _nombre
	  *                nombre del atributo
	  */
	 public String getNombre()
	 {
		 return _nombre;
	 }
	 
	  /**
      * Método para validar el nombre del atributo
      * @param nombreAtributo
      *          nombre  para el atributo con un formato a cumplir
      */
     
     public void validarNombre(String nombreAtributo)
     {
    	 _nombre = nombreAtributo;
    	 
    	 
    }
     
     
     /**
      * Método para validad la formula del atributo(segun formato dado y las dependencias permitidas)
      * @param formula
      *           fórmula con la cual se  calculará el valor del atributo
      * @return boolean 
      *           fórmula correcta = true o false = incorrecta
      */
     public boolean validarFormula(String formula)
     { 
         _formula = formula;
         aceptar.setEnabled(true);
         return true;
     }
     
     /***
      * Método para evaluar si el atributo esta bien definido
      * @return 
      *        booleano que indica si el atributo cumple con todas las condiones
      */
     public boolean evaluarAtributo()
     {
    	 
    	 return true; 	 
     }
     
     
     /**
      * Método para crear el atributo a nivel grafico
      * mediante el agregar una nuevo campo a la tabla casos además
      * solicita la creacion de un nuevo atributo a nivel lógico para lo cual 
	  * se envia como parametros:
	  *         - tipoc( 0 - cuantitativo, 1- cualitativo)
	  *         - numero de casos
	  *         - 
      * @throws  lanza excepcion al no poder crear el atributo
      */
     
     public void crearAtributoGrafico()
     {
    	 	
		/*
		 * dependiendo del tipo seleccionar las caracteristicas a mandar del tipo
		 */
    	 
		if(_tipo == 0)
		{
			//System.out.println(listaDecimales.getSelectedItem());
			_numeroDecimales = Integer.parseInt(listaDecimales.getSelectedItem().toString());
		}
		else
		{  
			_arregloTipos= new String[espacioMuestral.getItemCount()];
		
			for(int x = 0 ; x<_arregloTipos.length;x++)
			{
				_arregloTipos[x]= espacioMuestral.getItemAt(x).toString();
			}
		}
		
		
		/**
		 * @todo  invocar la realización de la clase atributo
		 */
		try
		{	
		   _columnas++;
		   modeloTablaCasos.setColumnCount(_columnas);


		   //---cambiar el header de las columnas
		   for(int x = 1; x< _columnas-1; x++)
		   {
			   tablita.getColumnModel().getColumn(x).setHeaderValue("");	
			   
		   }
		   
		    tablita.getColumnModel().getColumn(_columnas -1).setHeaderValue("Nuevo");	
		    tablita.setValueAt(_nombre,0,_columnas-2);
		  
		}
		catch (Exception e)
		{
				System.out.println(e.getMessage());
		}	 
     }
     
     public  JTable getTabla()
     {
    	 return tablita;
     }
}
